package main

import (
	"fmt"
	"log"
	"os"
	"path/filepath"
	"time"

	"mcp-server/internal/docprocessor"
	"mcp-server/internal/metadata"
	"mcp-server/internal/pipeline"
	"mcp-server/internal/qdrant"
	"mcp-server/internal/storage"
	"mcp-server/internal/vector"
)

func main() {
	fmt.Println("=== 文档处理流水线演示 ===")

	// 1. 初始化组件
	fmt.Println("\n1. 初始化组件...")

	// 文档处理器
	docProcessor := docprocessor.NewDocumentProcessor()

	// 元数据管理器
	metadataManager := metadata.NewDefaultManager("./metadata_storage")

	// Qdrant客户端
	qdrantClient := qdrant.NewSimpleQdrantClient()

	// 向量管理器
	vectorManager := vector.NewVectorManager(qdrantClient)
	if err := vectorManager.Initialize(nil); err != nil {
		log.Printf("向量管理器初始化失败: %v", err)
		// 继续演示，不依赖向量化
	}

	// 存储管理器
	storageManagerImpl := storage.NewStorageManager()

	// 2. 创建流水线管理器
	fmt.Println("2. 创建流水线管理器...")

	config := pipeline.DefaultPipelineConfig()
	config.MaxConcurrentTasks = 3
	config.WorkerPoolSize = 2

	pipelineManager := pipeline.NewPipelineManager(
		config,
		docProcessor,
		metadataManager,
		vectorManager,
		storageManagerImpl,
	)

	// 3. 启动流水线
	fmt.Println("3. 启动流水线...")
	if err := pipelineManager.Start(); err != nil {
		log.Fatalf("启动流水线失败: %v", err)
	}
	defer pipelineManager.Stop()

	// 4. 准备测试文件
	fmt.Println("4. 准备测试文件...")
	testFiles := prepareTestFiles()

	// 5. 提交单个任务
	fmt.Println("5. 提交单个任务...")
	if len(testFiles) > 0 {
		taskConfig := pipeline.DefaultTaskConfig()
		taskConfig.ExtractMetadata = true

		taskID, err := pipelineManager.SubmitTask(testFiles[0], taskConfig)
		if err != nil {
			log.Printf("提交任务失败: %v", err)
		} else {
			fmt.Printf("任务已提交: %s\n", taskID)

			// 监控任务进度
			monitorTask(pipelineManager, taskID)
		}
	}

	// 6. 批量提交任务
	if len(testFiles) > 1 {
		fmt.Println("\n6. 批量提交任务...")
		taskConfig := pipeline.DefaultTaskConfig()
		taskConfig.ExtractMetadata = true

		taskIDs, err := pipelineManager.SubmitBatch(testFiles[1:], taskConfig)
		if err != nil {
			log.Printf("批量提交任务失败: %v", err)
		} else {
			fmt.Printf("批量任务已提交: %d 个任务\n", len(taskIDs))

			// 监控所有任务
			for _, taskID := range taskIDs {
				go monitorTask(pipelineManager, taskID)
			}
		}
	}

	// 7. 等待任务完成
	fmt.Println("\n7. 等待任务完成...")
	time.Sleep(10 * time.Second)

	// 8. 显示最终统计
	fmt.Println("\n8. 最终统计:")
	showFinalStatistics(pipelineManager)

	fmt.Println("\n=== 演示完成 ===")
}

// prepareTestFiles 准备测试文件
func prepareTestFiles() []string {
	var testFiles []string

	// 检查样本知识目录
	sampleDir := "../../docs/样本知识 国资委监管制度"
	if _, err := os.Stat(sampleDir); err == nil {
		err := filepath.Walk(sampleDir, func(path string, info os.FileInfo, err error) error {
			if err != nil {
				return err
			}

			if !info.IsDir() && (filepath.Ext(path) == ".md" || filepath.Ext(path) == ".txt") {
				testFiles = append(testFiles, path)
			}

			return nil
		})

		if err != nil {
			log.Printf("遍历样本目录失败: %v", err)
		}
	}

	// 如果没有找到样本文件，创建测试文件
	if len(testFiles) == 0 {
		testFiles = createTestFiles()
	}

	fmt.Printf("找到 %d 个测试文件\n", len(testFiles))
	return testFiles
}

// createTestFiles 创建测试文件
func createTestFiles() []string {
	testDir := "./test_docs"
	os.MkdirAll(testDir, 0755)

	testContents := []struct {
		filename string
		content  string
	}{
		{
			"test1.md",
			`# 测试文档1

这是一个测试文档，用于演示文档处理流水线的功能。

## 主要内容

1. 文档解析功能
2. 元数据提取功能
3. 文本分片功能
4. 向量化功能
5. 存储功能

## 结论

流水线能够自动处理文档的完整生命周期。`,
		},
		{
			"test2.md",
			`# 测试文档2

这是第二个测试文档，包含更多的内容。

## 技术特性

- 并行处理能力
- 进度监控功能
- 错误处理机制
- 断点续传支持

## 性能指标

处理速度快，资源占用低，稳定性好。

## 应用场景

适用于大规模文档处理和知识库构建。`,
		},
		{
			"test3.txt",
			`测试文档3

这是一个纯文本文档，用于测试不同格式的文档处理能力。

内容包括：
- 基本文本处理
- 中文分词支持
- 语义分析功能
- 质量评估机制

测试结果将验证流水线的完整性和可靠性。`,
		},
	}

	var testFiles []string
	for _, test := range testContents {
		filePath := filepath.Join(testDir, test.filename)
		if err := os.WriteFile(filePath, []byte(test.content), 0644); err != nil {
			log.Printf("创建测试文件失败 %s: %v", filePath, err)
			continue
		}
		testFiles = append(testFiles, filePath)
	}

	return testFiles
}

// monitorTask 监控任务进度
func monitorTask(manager pipeline.Pipeline, taskID string) {
	fmt.Printf("开始监控任务: %s\n", taskID)

	for i := 0; i < 30; i++ { // 最多监控30秒
		progress, err := manager.GetProgress(taskID)
		if err != nil {
			log.Printf("获取任务进度失败 %s: %v", taskID, err)
			break
		}

		fmt.Printf("任务 %s: 阶段=%s, 状态=%s, 进度=%.1f%%\n",
			taskID[:8], progress.Stage, progress.Status, progress.Progress)

		if progress.Status == pipeline.StatusCompleted ||
			progress.Status == pipeline.StatusFailed ||
			progress.Status == pipeline.StatusCancelled {
			break
		}

		time.Sleep(1 * time.Second)
	}
}

// showFinalStatistics 显示最终统计
func showFinalStatistics(manager pipeline.Pipeline) {
	// 获取流水线指标
	metrics := manager.GetMetrics()
	fmt.Printf("流水线指标:\n")
	fmt.Printf("  总任务数: %d\n", metrics.TotalTasks)
	fmt.Printf("  已完成: %d\n", metrics.CompletedTasks)
	fmt.Printf("  失败: %d\n", metrics.FailedTasks)
	fmt.Printf("  活跃: %d\n", metrics.ActiveTasks)
	fmt.Printf("  排队: %d\n", metrics.QueuedTasks)
	fmt.Printf("  平均处理时间: %v\n", metrics.AverageTime)
	fmt.Printf("  吞吐量: %.2f 任务/分钟\n", metrics.ThroughputPerMin)
	fmt.Printf("  错误率: %.2f%%\n", metrics.ErrorRate*100)

	// 获取所有任务
	tasks, err := manager.ListTasks()
	if err != nil {
		log.Printf("获取任务列表失败: %v", err)
		return
	}

	fmt.Printf("\n任务详情:\n")
	for _, task := range tasks {
		fmt.Printf("  任务 %s:\n", task.ID[:8])
		fmt.Printf("    文件: %s\n", task.FileName)
		fmt.Printf("    状态: %s\n", task.Progress.Status)
		fmt.Printf("    进度: %.1f%%\n", task.Progress.Progress)
		if task.Progress.ErrorMessage != "" {
			fmt.Printf("    错误: %s\n", task.Progress.ErrorMessage)
		}
		if task.Result != nil {
			fmt.Printf("    处理时间: %v\n", task.Result.ProcessingTime)
			fmt.Printf("    生成向量: %d\n", task.Result.GeneratedVectors)
		}
	}
}
